package main

import (
	"fmt"
	"iter"   // 引入 iter 包，提供 Sequences（惰性生成器）相关功能
	"slices" // 提供 Collect 等切片操作工具
)

// 定义链表节点，泛型类型 T
type Node[T any] struct {
	next *Node[T] // 指向下一个节点
	val  T        // 当前节点的值
}

// 定义链表结构体，拥有头尾指针
type List[T any] struct {
	head, tail *Node[T]
}

// 向链表尾部添加一个元素
func (l *List[T]) push(val T) {
	if l.head == nil {
		// 如果是空链表，初始化头尾节点
		l.head = &Node[T]{val: val}
		l.tail = l.head
	} else {
		// 如果已有节点，则添加到末尾
		l.tail.next = &Node[T]{val: val}
		l.tail = l.tail.next
	}
}

// all 返回一个 iter.Seq[T]（生成器函数），可以用 range 来遍历整个链表
// iter.Seq[T] 是一种函数类型：func(yield func(T) bool)
// yield 是一个回调函数，你调用 yield(x) 就“产出”一个元素
func (l *List[T]) all() iter.Seq[T] {
	return func(yield func(T) bool) {
		for e := l.head; e != nil; e = e.next {
			// 把当前节点的值传给 yield
			// 如果 yield 返回 false，表示停止迭代
			if !yield(e.val) {
				return
			}
		}
	}
}

// genFib 返回一个生成器函数，动态生成斐波那契数列
// 使用无限 for 循环配合 yield 实现惰性生成
func genFib() iter.Seq[int] {
	return func(yield func(int) bool) {
		a, b := 1, 1
		for {
			// 产出当前数字
			if !yield(a) {
				return // 若外部不再需要数据（如 range 被 break 掉），则停止
			}
			// 计算下一个斐波那契数
			a, b = b, a+b
		}
	}
}

// 不常用不学了，看不懂
func main() {
	// 创建一个整数链表
	l := List[int]{}
	l.push(1)
	l.push(2)
	l.push(3)

	// 使用 range + all()（即 Sequences） 遍历链表
	for e := range l.all() {
		fmt.Println(e)
	}

	// 使用 slices.Collect 将生成器结果收集为切片
	all := slices.Collect(l.all())
	fmt.Println(all)

	// 使用 genFib() 生成无限斐波那契数列，直到 >10 为止
	for n := range genFib() {
		if n > 10 {
			break
		}
		fmt.Println(n)
	}
}
